home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava / classsrc / java / io / pipedi~1.jav < prev    next >
Encoding:
Text File  |  1995-08-11  |  4.4 KB  |  163 lines
  1. /*
  2.  * @(#)PipedInputStream.java    1.4 95/02/27 James Gosling
  3.  * 
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * Permission to use, copy, modify, and distribute this software and its
  7.  * documentation for NON-COMMERCIAL purposes and without fee is hereby
  8.  * granted provided that this copyright notice appears in all copies. Please
  9.  * refer to the file "copyright.html" for further important copyright and
  10.  * licensing information.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
  15.  * OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
  16.  * LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR
  17.  * ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.io;
  21.  
  22. /**
  23.  * Piped input stream, must be connected to a PipedOutputStream
  24.  * to be useful.
  25.  * @see    PipedOutputStream
  26.  * @see    Piped
  27.  * @version     95/02/27
  28.  * @author    James Gosling
  29.  */
  30. public
  31. class PipedInputStream extends InputStream {
  32.     boolean closed = true;    /* true iff this end or the other end has
  33.                  * been closed */
  34.     Thread readSide, writeSide;    /* The two ends of the pipe */
  35.  
  36.     /**
  37.      * Creates an input file given a PiledOutputStream.
  38.      * @param stream    the stream to connect to.
  39.      */
  40.     public PipedInputStream (PipedOutputStream src) {
  41.     connect(src);
  42.     }
  43.  
  44.     /**
  45.      * Creates an input file that isn't connected to anything (yet).
  46.      * It must be connected to a PipedOutputStream before being used.
  47.      */
  48.     public PipedInputStream () {
  49.     }
  50.  
  51.     /**
  52.      * Connect this input stream to a sender.
  53.      * @param src    The OutpueStream to connect to.
  54.      */
  55.     public void connect(PipedOutputStream src) {
  56.     src.connect(this);
  57.     }
  58.  
  59.     /* The circular buffer into which incoming data is placed */
  60.     private byte buffer[] = new byte[1024];
  61.  
  62.     /*
  63.      * fill and empty pointers.  in<0 implies the buffer is empty, in==out
  64.      * implies the buffer is full
  65.      */
  66.     int in = -1, out = 0;
  67.  
  68.     synchronized void recieve(int b) {
  69.     writeSide = Thread.currentThread();
  70.     while (in == out) {
  71.         if (readSide != null && !readSide.isAlive())
  72.         throw new IOException("Pipe broken");
  73.         notifyAll();    /* full: kick any waiting readers */
  74.         wait(1000);
  75.     }
  76.     if (in < 0) {
  77.         in = 0;
  78.         out = 0;
  79.     }
  80.     buffer[in++] = (byte) b;
  81.     if (in >= buffer.length)
  82.         in = 0;
  83.     }
  84.  
  85.     synchronized void recieve(byte b[], int off, int len) {
  86.     while (--len >= 0)
  87.         recieve(b[off++]);
  88.     }
  89.  
  90.     synchronized void recievedLast() {
  91.     closed = true;
  92.     notifyAll();
  93.     }
  94.  
  95.     /**
  96.      * Reads a byte. Will block if no input is available.
  97.      * @return     the byte read, or -1 if the end of the
  98.      *        stream is reached.
  99.      */
  100.     public synchronized int read() {
  101.     int trials = 2;
  102.     while (in < 0) {
  103.         readSide = Thread.currentThread();
  104.         if (writeSide != null && !writeSide.isAlive() && --trials<0)
  105.         throw new IOException("Pipe broken");
  106.         if (closed)
  107.         return -1;
  108.         notifyAll();    /* might be a writer waiting */
  109.         wait(1000);
  110.     }
  111.     int ret = buffer[out++];
  112.     if (out >= buffer.length)
  113.         out = 0;
  114.     if (in == out)
  115.         in = -1;        /* now empty */
  116.     return ret;
  117.     }
  118.  
  119.     /**
  120.      * Reads into an array of bytes.
  121.      * Blocks until some input is available.
  122.      * For efficiency,this method should be overridden in a subclass
  123.      * (the default implementation reads 1 byte
  124.      * at a time).
  125.      * @param b    the buffer into which the data is read
  126.      * @param off the start offset of the data
  127.      * @param len the maximum number of bytes read
  128.      * @return  the actual number of bytes read, -1 is
  129.      *         returned when the end of the stream is reached.
  130.      * @exception IOException i/o error occurred
  131.      */
  132.     public synchronized int read(byte b[], int off, int len) {
  133.     if (len <= 0)
  134.         return 0;
  135.     int c = read();        /* possibly wait on the first character */
  136.     if (c < 0)
  137.         return -1;
  138.     b[off] = (byte) c;
  139.     int rlen = 1;
  140.     while (in >= 0 && --len > 0) {
  141.         b[off + rlen] = buffer[out++];
  142.         rlen++;
  143.         if (out >= buffer.length)
  144.         out = 0;
  145.         if (in == out)
  146.         in = -1;    /* now empty */
  147.     }
  148.     return rlen;
  149.     }
  150.  
  151.     /**
  152.      * Closes the input stream. Must be called
  153.      * to release any resources associated with
  154.      * the stream.
  155.      * @exception IOException i/o error occurred
  156.      */
  157.     public void close() {
  158.     in = -1;
  159.     closed = true;
  160.     }
  161.  
  162. }
  163.